/**
 * 模块加载器 - 用于动态加载HTML模块
 */
class ModuleLoader {
    constructor() {
        this.loadedModules = new Set();
        this.moduleCache = new Map();
    }

    /**
     * 加载单个模块
     * @param {string} moduleName - 模块名称
     * @param {string} containerId - 容器ID
     * @returns {Promise<void>}
     */
    async loadModule(moduleName, containerId = null) {
        if (this.loadedModules.has(moduleName)) {
            return;
        }

        try {
            let moduleContent;
            
            // 检查缓存
            if (this.moduleCache.has(moduleName)) {
                moduleContent = this.moduleCache.get(moduleName);
            } else {
                const response = await fetch(`modules/${moduleName}.html`);
                if (!response.ok) {
                    throw new Error(`Failed to load module: ${moduleName}`);
                }
                moduleContent = await response.text();
                this.moduleCache.set(moduleName, moduleContent);
            }

            // 如果指定了容器ID，直接插入到容器中
            if (containerId) {
                const container = document.getElementById(containerId);
                if (container) {
                    container.innerHTML = moduleContent;
                }
            } else {
                // 否则添加到body末尾
                const tempDiv = document.createElement('div');
                tempDiv.innerHTML = moduleContent;
                document.body.appendChild(tempDiv.firstElementChild);
            }

            this.loadedModules.add(moduleName);
            
        } catch (error) {
            console.error(`Error loading module ${moduleName}:`, error);
            throw error;
        }
    }

    /**
     * 批量加载模块
     * @param {Array<string|Object>} modules - 模块列表
     * @returns {Promise<void>}
     */
    async loadModules(modules) {
        const loadPromises = modules.map(module => {
            if (typeof module === 'string') {
                return this.loadModule(module);
            } else if (typeof module === 'object' && module.name) {
                return this.loadModule(module.name, module.containerId);
            }
        });

        try {
            await Promise.all(loadPromises);
            
        } catch (error) {
            console.error('Error loading modules:', error);
            throw error;
        }
    }

    /**
     * 卸载模块
     * @param {string} moduleName - 模块名称
     */
    unloadModule(moduleName) {
        this.loadedModules.delete(moduleName);
        // 注意：这里只是从记录中移除，实际DOM元素需要手动清理
    }

    /**
     * 重新加载模块
     * @param {string} moduleName - 模块名称
     * @param {string} containerId - 容器ID
     * @returns {Promise<void>}
     */
    async reloadModule(moduleName, containerId = null) {
        this.unloadModule(moduleName);
        this.moduleCache.delete(moduleName);
        await this.loadModule(moduleName, containerId);
    }

    /**
     * 检查模块是否已加载
     * @param {string} moduleName - 模块名称
     * @returns {boolean}
     */
    isModuleLoaded(moduleName) {
        return this.loadedModules.has(moduleName);
    }

    /**
     * 清理所有模块缓存
     */
    clearCache() {
        this.moduleCache.clear();
        this.loadedModules.clear();
    }
}

// 创建全局模块加载器实例
window.moduleLoader = new ModuleLoader();

/**
 * 初始化应用程序模块
 */
async function initializeApp() {
    try {
        // 定义要加载的模块
        const modules = [
            { name: 'sidebar', containerId: 'sidebar-container' },
            { name: 'top-nav', containerId: 'top-nav-container' },
            { name: 'chat', containerId: 'chat-container' },
            { name: 'knowledge', containerId: 'knowledge-container' },
            { name: 'documents', containerId: 'documents-container' },
            { name: 'document-content', containerId: 'doc-content-container' },
            { name: 'add-document', containerId: 'add-document-container' },
            { name: 'settings', containerId: 'settings-container' },
            { name: 'modals', containerId: 'modals-container' }
        ];

        // 加载所有模块
        await window.moduleLoader.loadModules(modules);
        
        // 模块加载完成后的初始化
        
        
        // 触发自定义事件，通知其他脚本模块已加载完成
        document.dispatchEvent(new CustomEvent('modulesLoaded'));
        
    } catch (error) {
        console.error('Failed to initialize app modules:', error);
        // 可以在这里显示错误信息给用户
        showErrorMessage('应用程序模块加载失败，请刷新页面重试');
    }
}

/**
 * 显示错误消息
 * @param {string} message - 错误消息
 */
function showErrorMessage(message) {
    const errorDiv = document.createElement('div');
    errorDiv.className = 'error-message';
    errorDiv.style.cssText = `
        position: fixed;
        top: 20px;
        right: 20px;
        background: #f44336;
        color: white;
        padding: 15px;
        border-radius: 5px;
        z-index: 10000;
        max-width: 300px;
    `;
    errorDiv.textContent = message;
    document.body.appendChild(errorDiv);
    
    // 5秒后自动移除
    setTimeout(() => {
        if (errorDiv.parentNode) {
            errorDiv.parentNode.removeChild(errorDiv);
        }
    }, 5000);
}

// 当DOM加载完成时初始化应用
if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', initializeApp);
} else {
    initializeApp();
} 